using Godot;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text.Json;
using System.Text.Encodings.Web;
using System.Text.Unicode;

namespace Smr
{
    namespace 枚举
    {
        public enum E角色战斗站位
        {
            本后中,
            本后上,
            本后下,
            本前中,
            本前上,
            本前下,
            敌后中,
            敌后上,
            敌后下,
            敌前中,
            敌前上,
            敌前下,
        }
        public enum E角色战斗状态
        {
            正常,
            死亡,
            封印,
        }
        public enum E角色战斗类型
        {
            玩家,
            队友,
            宠物,
            敌人,
        }
        public enum E角色称谓
        {
            鬼卒,
            鬼差,
            鬼使,
            鬼判,
            鬼帅,
            鬼司,
            鬼将,
            鬼王,
            鬼帝,
            鬼尊
        }
        public enum E角色职级
        {
            一级,
            二级,
            三级,
            四级,
            五级,
            六级,
            七级,
            八级,
            九级,
            十级
        }
        public enum E道具类型
        {
            装备,
            宠物,
            材料,
            消耗,
            任务,
        }
        public enum E道具品质
        {
            凡品,
            灵品,
            地品,
            天品,
            玄品,
            圣品
        }
        public enum E道具品级
        {
            初级,
            中级,
            高级,
            终极,
        }
        public enum E装备部位
        {
            法器,
            帽子,
            衣服,
            鞋子,
            腰带,
            项链,
            戒指,
            手镯
        }
        public enum E装备前缀
        {
            定神,
            驱邪,
            镇魂,
            无常,
            冥火,
            阴阳,
            摄魄,
            灭煞,
            灵媒,
            轮回
        }
        public enum E道具位置
        {
            背包,
            装备栏,
            装备拆分,
            装备重组
        }
        public enum E道具介绍按钮类型
        {
            装备,
            卸下,
            使用,
        }
        public enum E背包道具使用状态
        {
            不判断,
            未使用,
            已使用,
        }
        public enum E宠物类型
        {
            普通,
            神兽,
            特殊,
        }
    }
    namespace 接口
    {
        public interface I基础属性
        {
            /// <summary>
            /// 角色在游戏世界中的代号。
            /// </summary>
            string 名称 { get; set; }
            /// <summary>
            /// 角色在游戏世界中的类型，是玩家？是队友？是宠物？还是敌人。
            /// </summary>
            枚举.E角色战斗类型 战斗类型 { get; set; }
            /// <summary>
            /// 角色在游戏世界中实力的象征，称谓越高，代表着在游戏世界里地位越高。
            /// </summary>
            枚举.E角色称谓 称谓 { get; set; }
            /// <summary>
            /// 角色在游戏世界中称谓的职级，职级越高，代表在同称谓中的实力越高。
            /// </summary>
            枚举.E角色职级 职级 { get; set; }
            /// <summary>
            /// 角色在游戏世界中当前职级的经验值，可通过野外挂机、任务等获取。
            /// 当前职级经验满后，可以晋级到下一级职级，当职级到达十级后，可参加称谓挑战，挑战成功后晋升下一级称谓。
            /// </summary>
            float 当前职级经验 { get; set; }
            /// <summary>
            /// 角色在游戏世界中的存活时间，当阳寿到零时，游戏失败。
            /// </summary>
            float 阳寿 { get; set; }
            /// <summary>
            /// 角色在游戏世界中付出的体现，阴德越高，说明对地府的贡献越大。
            /// </summary>
            float 阴德 { get; set; }
            /// <summary>
            /// 角色在游戏世界中坚定的毅力，能在战斗中，抵抗敌人发动攻击时的负面影响。
            /// </summary>
            float 毅力 { get; set; }
            /// <summary>
            /// 未分配的点数可以分配给角色四维属性
            /// </summary>
            float 未分配的点数 { get; set; }
        }
        public interface I战斗属性
        {
            /// <summary>
            /// 增加角色体质、爆发、精神、敏捷的属性
            /// </summary>
            float 所有属性 { get; set; }
            /// <summary>
            /// 增加角色的物伤和神伤
            /// </summary>
            float 伤害 { get; set; }

            /// <summary>
            /// 提高角色体力上限和防御，降低敌人对自己的攻击效果。
            /// </summary>
            float 体质 { get; set; }
            /// <summary>
            /// 提高角色物伤，加强对敌人的爆发攻击效果。
            /// </summary>
            float 爆发 { get; set; }
            /// <summary>
            /// 提高角色精力上限和神伤，加强对敌人的神伤攻击效果。
            /// </summary>
            float 精神 { get; set; }
            /// <summary>
            /// 提高角色速度，加快在战斗过程中每回合的出手速度。
            /// </summary>
            float 敏捷 { get; set; }

            /// <summary>
            /// 影响角色的体力值, 体力为零时, 角色无法使用任何操作
            /// </summary>
            float 体力 { get; set; }
            /// <summary>
            /// 影响角色的精力值, 精力为零时, 角色无法对敌人使用精神攻击, 但可以对敌人身体造成伤害
            /// </summary>
            float 精力 { get; set; }
            /// <summary>
            /// 影响角色使用爆发攻击时对敌人的身体伤害
            /// </summary>
            float 物伤 { get; set; }
            /// <summary>
            /// 影响角色使用精神攻击时对敌人的大脑伤害
            /// </summary>
            float 神伤 { get; set; }
            /// <summary>
            /// 影响角色的出手先后顺序
            /// </summary>
            float 速度 { get; set; }
            /// <summary>
            /// 影响角色的防御力, 防御力越高受到敌人的伤害越小
            /// </summary>
            float 防御 { get; set; }

            /// <summary>
            /// 影响角色使用爆发攻击时的命中概率
            /// </summary>
            float 命中率 { get; set; }
            /// <summary>
            /// 影响角色爆发攻击出现命中时的攻击加成
            /// </summary>
            float 命中值 { get; set; }
            /// <summary>
            /// 影响角色使用爆发攻击时的暴击概率
            /// </summary>
            float 暴击率 { get; set; }
            /// <summary>
            /// 影响角色使用爆发攻击出现暴击时的伤害加成
            /// </summary>
            float 暴击值 { get; set; }
            /// <summary>
            /// 增加角色在爆发攻击时产生连击的概率，需要连击数的搭配才能起到作用
            /// </summary>
            float 连击率 { get; set; }
            /// <summary>
            /// 角色在爆发攻击时会产生连击，连击伤害只有前一次攻击的一半，以此类推
            /// </summary>
            float 连击数 { get; set; }
            /// <summary>
            /// 增加角色在被爆发攻击时反震的概率，需要反震度的搭配才能起到作用
            /// </summary>
            float 反震率 { get; set; }
            /// <summary>
            /// 角色在被爆发攻击时产生伤害反弹，反弹数值由反震度决定
            /// </summary>
            float 反震度 { get; set; }
            /// <summary>
            /// 影响角色被暴击时的暴击加成抵消
            /// </summary>
            float 韧性 { get; set; }
            /// <summary>
            /// 影响角色被命中时的命中加成抵消
            /// </summary>
            float 抵抗 { get; set; }
        }
        public interface I角色模型
        {
            string UUID { get; set; }
            I基础属性 基础属性 { get; set; }
            I战斗属性 战斗属性 { get; set; }
            基类.C角色模型 取综合属性(基类.C战斗属性 装备属性);
            int 取等级四维属性();
            float 取四维属性对战斗属性加成(string 属性名);
        }
        public interface I敌人模型 : I角色模型
        {
            IReadOnlyList<索引.E道具索引> 掉落道具 { get; set; }
            IReadOnlyList<int> 掉落经验 { get; set; }
        }
        public interface I宠物成长
        {
            float 体力下限 { get; set; }
            float 体力上限 { get; set; }
            float 体力成长 { get; set; }
            float 精力下限 { get; set; }
            float 精力上限 { get; set; }
            float 精力成长 { get; set; }
            float 物伤下限 { get; set; }
            float 物伤上限 { get; set; }
            float 物伤成长 { get; set; }
            float 神伤下限 { get; set; }
            float 神伤上限 { get; set; }
            float 神伤成长 { get; set; }
            float 速度下限 { get; set; }
            float 速度上限 { get; set; }
            float 速度成长 { get; set; }
            float 防御下限 { get; set; }
            float 防御上限 { get; set; }
            float 防御成长 { get; set; }
        }
        public interface I宠物模型
        {
            I宠物成长 成长 { get; set; }
            枚举.E宠物类型 类型 { get; set; }
            bool 是否参战 { get; set; }
        }
        public interface I地图模型
        {
            IReadOnlyList<索引.E敌人索引> 敌人 { get; }
            IReadOnlyList<索引.E装备索引> 装备 { get; }
        }
        public interface I道具模型
        {
            string UUID { get; set; }
            int 索引 { get; set; }
            string 名称 { get; set; }
            string 描述 { get; set; }
            枚举.E道具类型 类型 { get; set; }
            枚举.E道具品质 品质 { get; set; }
            枚举.E道具品级 品级 { get; set; }
            bool 可叠加 { get; set; }
            int 叠加上限 { get; set; }
            bool 可出售 { get; set; }
            int 出售价格 { get; set; }
            int 当前数量 { get; set; }
            枚举.E道具位置 道具位置 { get; set; }
            string 背景颜色 { get; set; }
            bool 已使用 { get; set; }
        }
        public interface I装备模型 : I道具模型
        {
            枚举.E装备部位 部位 { get; set; }
            枚举.E角色称谓 称谓要求 { get; set; }
            结构.装备属性 基础属性一 { get; set; }
            结构.装备属性 基础属性二 { get; set; }
            List<结构.装备属性> 附加属性 { get; set; }
        }
    }
    namespace 基类
    {
        public class C基础属性 : 接口.I基础属性
        {
            public string 名称 { get; set; } = "角色模板";
            public 枚举.E角色战斗类型 战斗类型 { get; set; } = 枚举.E角色战斗类型.玩家;
            public 枚举.E角色称谓 称谓 { get; set; } = 枚举.E角色称谓.鬼卒;
            public 枚举.E角色职级 职级 { get; set; } = 枚举.E角色职级.一级;
            public float 当前职级经验 { get; set; } = 0;
            public float 阳寿 { get; set; } = 30;
            public float 阴德 { get; set; } = 0;
            public float 毅力 { get; set; } = 0;
            public float 未分配的点数 { get; set; } = 0;
        }
        public class C战斗属性 : 接口.I战斗属性
        {
            public float 所有属性 { get; set; } = 0;
            public float 伤害 { get; set; } = 0;

            public float 体质 { get; set; } = 0;
            public float 爆发 { get; set; } = 0;
            public float 精神 { get; set; } = 0;
            public float 敏捷 { get; set; } = 0;

            public float 体力 { get; set; } = 0;
            public float 精力 { get; set; } = 0;
            public float 物伤 { get; set; } = 0;
            public float 神伤 { get; set; } = 0;
            public float 防御 { get; set; } = 0;
            public float 速度 { get; set; } = 0;

            public float 命中率 { get; set; } = 0;
            public float 命中值 { get; set; } = 0;
            public float 暴击率 { get; set; } = 0;
            public float 暴击值 { get; set; } = 0;
            public float 连击率 { get; set; } = 0;
            public float 连击数 { get; set; } = 0;
            public float 反震率 { get; set; } = 0;
            public float 反震度 { get; set; } = 0;
            public float 韧性 { get; set; } = 0;
            public float 抵抗 { get; set; } = 0;
        }
        public class C角色模型 : 接口.I角色模型
        {
            public string UUID { get; set; } = Guid.NewGuid().ToString();
            public 接口.I基础属性 基础属性 { get; set; } = new C基础属性();
            public 接口.I战斗属性 战斗属性 { get; set; } = new C战斗属性();
            public C角色模型 取综合属性(C战斗属性 装备属性)
            {
                C角色模型 副本 = new()
                {
                    UUID = UUID,
                };

                // 基础属性
                副本.基础属性.名称 = 基础属性.名称;
                副本.基础属性.战斗类型 = 基础属性.战斗类型;
                副本.基础属性.称谓 = 基础属性.称谓;
                副本.基础属性.阴德 = 基础属性.阴德;

                switch (基础属性.战斗类型)
                {
                    case 枚举.E角色战斗类型.玩家:
                    case 枚举.E角色战斗类型.队友:
                    case 枚举.E角色战斗类型.敌人:
                        // 四维属性
                        副本.战斗属性.体质 = 取等级四维属性() + 战斗属性.体质 + 装备属性.体质 + 装备属性.所有属性;
                        副本.战斗属性.爆发 = 取等级四维属性() + 战斗属性.爆发 + 装备属性.爆发 + 装备属性.所有属性;
                        副本.战斗属性.精神 = 取等级四维属性() + 战斗属性.精神 + 装备属性.精神 + 装备属性.所有属性;
                        副本.战斗属性.敏捷 = 取等级四维属性() + 战斗属性.敏捷 + 装备属性.敏捷 + 装备属性.所有属性;

                        // 初始战斗属性 + 比例四维属性
                        副本.战斗属性.体力 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.体力));
                        副本.战斗属性.精力 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.精力));
                        副本.战斗属性.物伤 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.物伤));
                        副本.战斗属性.神伤 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.神伤));
                        副本.战斗属性.防御 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.防御));
                        副本.战斗属性.速度 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.速度));

                        // 战斗属性 + 装备属性
                        副本.战斗属性.体力 = 副本.战斗属性.体力 + 装备属性.体力;
                        副本.战斗属性.精力 = 副本.战斗属性.精力 + 装备属性.精力;
                        副本.战斗属性.物伤 = 副本.战斗属性.物伤 + 装备属性.物伤 + 装备属性.伤害;
                        副本.战斗属性.神伤 = 副本.战斗属性.神伤 + 装备属性.神伤 + 装备属性.伤害;
                        副本.战斗属性.防御 = 副本.战斗属性.防御 + 装备属性.防御;
                        副本.战斗属性.速度 = 副本.战斗属性.速度 + 装备属性.速度;

                        // 装备属性
                        副本.战斗属性.命中率 = 装备属性.命中率;
                        副本.战斗属性.命中值 = 装备属性.命中值;
                        副本.战斗属性.暴击率 = 装备属性.暴击率;
                        副本.战斗属性.暴击值 = 装备属性.暴击值;
                        副本.战斗属性.连击率 = 装备属性.连击率;
                        副本.战斗属性.连击数 = 装备属性.连击数;
                        副本.战斗属性.反震率 = 装备属性.反震率;
                        副本.战斗属性.反震度 = 装备属性.反震度;
                        副本.战斗属性.韧性 = 装备属性.韧性;
                        副本.战斗属性.抵抗 = 装备属性.抵抗;
                        break;
                    case 枚举.E角色战斗类型.宠物:
                        // 四维属性
                        副本.战斗属性.体质 = 取等级四维属性() + 战斗属性.体质;
                        副本.战斗属性.爆发 = 取等级四维属性() + 战斗属性.爆发;
                        副本.战斗属性.精神 = 取等级四维属性() + 战斗属性.精神;
                        副本.战斗属性.敏捷 = 取等级四维属性() + 战斗属性.敏捷;

                        // 初始战斗属性 + 比例四维属性
                        副本.战斗属性.体力 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.体力));
                        副本.战斗属性.精力 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.精力));
                        副本.战斗属性.物伤 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.物伤));
                        副本.战斗属性.神伤 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.神伤));
                        副本.战斗属性.防御 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.防御));
                        副本.战斗属性.速度 = 取四维属性对战斗属性加成(nameof(接口.I战斗属性.速度));
                        break;
                    default:
                        break;
                }

                return 副本;
            }

            public int 取等级四维属性()
            {
                return (int)基础属性.称谓 * 10 + (int)基础属性.职级 + 1;
            }

            public int 取等级属性点总数()
            {
                return ((int)基础属性.称谓 * 10 + (int)基础属性.职级) * 4;
            }

            public float 取四维属性对战斗属性加成(string 属性名)
            {
                // // 四维属性对基础属性的影响比例
                // 体力 = 体质 * 1.5f + 爆发 * 0.2f + 精神 * 0.3f + 敏捷 * 0.1f;
                // 精力 = 精神 * 1.5f + 体质 * 0.3f + 爆发 * 0.1f + 敏捷 * 0.1f;
                // 物伤 = 爆发 * 1.8f + 敏捷 * 0.5f + 体质 * 0.1f - 精神 * 0.1f;
                // 神伤 = 精神 * 1.8f + 敏捷 * 0.3f + 爆发 * 0.2f - 体质 * 0.1f;
                // 速度 = 敏捷 * 2.0f + 精神 * 0.2f + 爆发 * 0.1f - 体质 * 0.2f;
                // 防御 = 体质 * 1.2f + 敏捷 * 0.5f + 精神 * 0.3f;

                // 设计思路说明：
                // 体力：主要受体质影响(1.5)，其次精神(0.3)也有一定贡献，因为精神影响精力上限，与体力共同构成生存能力。
                // 精力：主要受精神影响(1.5)，体质(0.3)也有一定贡献，因为体质好的角色精力恢复可能更快。
                // 物伤：主要受爆发影响(1.8)，敏捷(0.5)增加攻击精准度，少量负精神(-0.1)表示过于专注精神可能降低物理攻击。
                // 神伤：主要受精神影响(1.8)，敏捷(0.3)增加施法速度，少量负体质(-0.1)表示身体过于强壮可能影响精神专注。
                // 速度：主要受敏捷影响(2.0)，少量负体质(-0.2)表示身体笨重可能降低速度。
                // 防御：主要受体质影响(1.2)，敏捷(0.5)增加闪避能力，精神(0.3)增加对精神攻击的抗性。

                // 这个设计：
                // 确保每个四维属性都有明确的主攻方向
                // 保持属性间的合理平衡
                // 允许玩家通过不同加点发展出不同流派(如高爆发物理流、高精神法术流、均衡流等)
                // 包含少量负相关体现属性间的制约关系

                float 返回值 = 0;
                switch (属性名)
                {
                    case nameof(接口.I战斗属性.体力):
                        返回值 = 战斗属性.体质 * 1.5f + 战斗属性.爆发 * 0.2f + 战斗属性.精神 * 0.3f + 战斗属性.敏捷 * 0.1f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.体力 : 配置.角色初始战斗属性.体力);
                        break;
                    case nameof(接口.I战斗属性.精力):
                        返回值 = 战斗属性.精神 * 1.5f + 战斗属性.体质 * 0.3f + 战斗属性.爆发 * 0.1f + 战斗属性.敏捷 * 0.1f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.精力 : 配置.角色初始战斗属性.精力);
                        break;
                    case nameof(接口.I战斗属性.物伤):
                        返回值 = 战斗属性.爆发 * 1.8f + 战斗属性.敏捷 * 0.5f + 战斗属性.体质 * 0.1f - 战斗属性.精神 * 0.1f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.物伤 : 配置.角色初始战斗属性.物伤);
                        break;
                    case nameof(接口.I战斗属性.神伤):
                        返回值 = 战斗属性.精神 * 1.8f + 战斗属性.敏捷 * 0.3f + 战斗属性.爆发 * 0.2f - 战斗属性.体质 * 0.1f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.神伤 : 配置.角色初始战斗属性.神伤);
                        break;
                    case nameof(接口.I战斗属性.速度):
                        返回值 = 战斗属性.敏捷 * 2.0f + 战斗属性.精神 * 0.2f + 战斗属性.爆发 * 0.1f - 战斗属性.体质 * 0.2f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.速度 : 配置.角色初始战斗属性.速度);
                        break;
                    case nameof(接口.I战斗属性.防御):
                        返回值 = 战斗属性.体质 * 1.2f + 战斗属性.敏捷 * 0.5f + 战斗属性.精神 * 0.3f + (基础属性.战斗类型 == 枚举.E角色战斗类型.敌人 ? 配置.敌人初始战斗属性.防御 : 配置.角色初始战斗属性.防御);
                        break;
                    default:
                        break;
                }
                return 返回值;
            }
        }
        public class C敌人模型 : C角色模型, 接口.I敌人模型
        {
            public IReadOnlyList<索引.E道具索引> 掉落道具 { get; set; } = [];
            public IReadOnlyList<int> 掉落经验 { get; set; } = [];
        }
        public class C宠物成长 : 接口.I宠物成长
        {
            public float 体力下限 { get; set; } = 0;
            public float 体力上限 { get; set; } = 0;
            public float 体力成长 { get; set; } = 0;
            public float 精力下限 { get; set; } = 0;
            public float 精力上限 { get; set; } = 0;
            public float 精力成长 { get; set; } = 0;
            public float 物伤下限 { get; set; } = 0;
            public float 物伤上限 { get; set; } = 0;
            public float 物伤成长 { get; set; } = 0;
            public float 神伤下限 { get; set; } = 0;
            public float 神伤上限 { get; set; } = 0;
            public float 神伤成长 { get; set; } = 0;
            public float 速度下限 { get; set; } = 0;
            public float 速度上限 { get; set; } = 0;
            public float 速度成长 { get; set; } = 0;
            public float 防御下限 { get; set; } = 0;
            public float 防御上限 { get; set; } = 0;
            public float 防御成长 { get; set; } = 0;
        }
        public class C宠物模型 : C角色模型, 接口.I宠物模型
        {
            public 接口.I宠物成长 成长 { get; set; } = new C宠物成长();
            public 枚举.E宠物类型 类型 { get; set; } = 枚举.E宠物类型.普通;
            public bool 是否参战 { get; set; } = false;

            public float 取当前总成长()
            {
                return 成长.体力成长 + 成长.精力成长 + 成长.物伤成长 + 成长.神伤成长 + 成长.速度成长 + 成长.防御成长;
            }
            public float 取总成长上限()
            {
                return 成长.体力上限 + 成长.精力上限 + 成长.物伤上限 + 成长.神伤上限 + 成长.速度上限 + 成长.防御上限;
            }
        }
        public class C地图模型 : 接口.I地图模型
        {
            public IReadOnlyList<索引.E敌人索引> 敌人 { get; set; } = [];
            public IReadOnlyList<索引.E装备索引> 装备 { get; set; } = [];
        }
        public class C道具模型 : 接口.I道具模型
        {
            public string UUID { get; set; } = Guid.NewGuid().ToString();
            public int 索引 { get; set; } = 0;
            public string 名称 { get; set; } = "道具模板";
            public string 描述 { get; set; } = "这里是道具的模板";
            public 枚举.E道具类型 类型 { get; set; }
            public 枚举.E道具品质 品质 { get; set; }
            public 枚举.E道具品级 品级 { get; set; }
            public bool 可叠加 { get; set; } = true;
            public int 叠加上限 { get; set; } = 20;
            public bool 可出售 { get; set; } = true;
            public int 出售价格 { get; set; } = 1;
            public int 当前数量 { get; set; } = 1;
            public 枚举.E道具位置 道具位置 { get; set; } = 枚举.E道具位置.背包;
            public string 背景颜色 { get; set; } = "";
            public bool 已使用 { get; set; } = false;
        }
        public class C装备模型 : C道具模型, 接口.I装备模型
        {
            public 枚举.E装备部位 部位 { get; set; }
            public 枚举.E角色称谓 称谓要求 { get; set; }
            public 结构.装备属性 基础属性一 { get; set; }
            public 结构.装备属性 基础属性二 { get; set; }
            public List<结构.装备属性> 附加属性 { get; set; } = [];
        }
    }
    namespace 索引
    {
        public enum E地图索引
        {
            初始值 = 10000,
            新手村
        }
        public enum E敌人索引
        {
            初始值 = 20000,
            开心鬼,
            少女鬼
        }
        public enum E道具索引
        {
            初始值 = 30000,
            初级精魄,
            棒棒糖,
            少女泪,
            拆分石,
        }
        public enum E装备索引
        {
            初始值 = 40000,
            定神道器,
            定神道帽,
            定神道袍,
            定神道靴,
        }
        public enum E宠物索引
        {
            初始值 = 50000,
            兔小白,
        }
    }
    public static class 配置
    {
        public static class 角色初始战斗属性
        {
            public readonly static float 体力 = 120;
            public readonly static float 精力 = 100;
            public readonly static float 物伤 = 80;
            public readonly static float 神伤 = 60;
            public readonly static float 速度 = 10;
            public readonly static float 防御 = 40;
        }
        public static class 敌人初始战斗属性
        {
            public readonly static float 体力 = 100;
            public readonly static float 精力 = 80;
            public readonly static float 物伤 = 60;
            public readonly static float 神伤 = 40;
            public readonly static float 速度 = 6;
            public readonly static float 防御 = 20;
        }
        public static class 宠物成长计算系数
        {
            public readonly static float 体力 = 1.5f;
            public readonly static float 精力 = 1.5f;
            public readonly static float 物伤 = 1.2f;
            public readonly static float 神伤 = 1.2f;
            public readonly static float 速度 = 1.3f;
            public readonly static float 防御 = 1.3f;
        }
        public readonly static IReadOnlyList<float> 职级经验上限数组 =
        [
            1000,
            2000,
            3000,
            4000,
            5000,
            6000,
            7000,
            8000,
            9000,
            10000,
        ];
        public readonly static IReadOnlyList<string> 道具品级颜色 = ["#95d475", "#79bbff", "#eebe77", "#f89898"];
        public readonly static IReadOnlyList<float> 战斗加速 = [1f, 0.5f, 0.25f];
        public readonly static string 附加属性标签颜色 = "#006dd8";
        public readonly static DateTime 世界初始时间 = new(3000, 1, 1);
        public readonly static IReadOnlyList<int> 随机遇敌间隔 = [3, 7]; // [3, 7]
        public readonly static IReadOnlyList<int> 随机野外掉落装备概率 = [1, 2]; // [0, 2]
        public readonly static IReadOnlyList<int> 随机野外掉落装备附加属性数量概率 = [-1, 3]; // [-1, 3]
        public readonly static float 装备拆分阴德消耗 = 999;
        public readonly static int 装备拆分成功几率 = 55; // 55
        public readonly static float 装备重组阴德消耗 = 666;
        public readonly static int 宠物参战上限 = 1;
    }
    public static class 结构
    {
        public struct 装备属性
        {
            public string 属性名;
            public float 当前值;
            public float 上限值;
            public float 下限值;
        };
    }
    public static class 方法
    {
        public readonly static Random 取随机数 = new();

        public static bool 取概率结果(float 概率, int 概率上限 = 100)
        {
            return 概率 >= 取随机数.Next(1, 概率上限 + 1);
        }

        public static object 取指定对象的指定属性值(object 对象, string 属性名)
        {
            ArgumentNullException.ThrowIfNull(对象);
            if (string.IsNullOrEmpty(属性名)) throw new ArgumentException("属性名称不能为空", nameof(属性名));
            PropertyInfo propertyInfo = 对象.GetType().GetProperty(属性名) ?? throw new ArgumentException($"属性 '{属性名}' 在类型 '{对象.GetType().FullName}' 中不存在。");
            return propertyInfo.GetValue(对象);
        }

        public static void 置指定对象的指定属性值(object 对象, string 属性名, object 新值)
        {
            ArgumentNullException.ThrowIfNull(对象);
            if (string.IsNullOrEmpty(属性名)) throw new ArgumentException("属性名称不能为空", nameof(属性名));
            PropertyInfo propertyInfo = 对象.GetType().GetProperty(属性名) ?? throw new ArgumentException($"属性 '{属性名}' 在类型 '{对象.GetType().FullName}' 中不存在。");
            if (!propertyInfo.CanWrite)
                throw new InvalidOperationException($"属性 '{属性名}' 是只读的，无法设置值。");
            propertyInfo.SetValue(对象, 新值);
        }

        public static string 对象转JSON字符串(object 对象)
        {
            var options = new JsonSerializerOptions
            {
                // 允许所有 Unicode 字符（包括中文）
                Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
                // 格式化输出（换行+缩进）
                WriteIndented = true
            };
            return JsonSerializer.Serialize(对象, options);
        }

        public static void 节点被点击(InputEvent @event)
        {
            if (@event is InputEventMouseButton mouseEvent)
            {
                if (mouseEvent.ButtonIndex == MouseButton.Left && mouseEvent.Pressed)
                {

                }
            }
        }

        public static float 四舍五入(float 数值, int 保留位数)
        {
            float 系数 = Mathf.Pow(10, 保留位数);
            return Mathf.Round(数值 * 系数) / 系数;
        }
    }
}
